import { mapState } from 'vuex'
import { deviceApi } from '../../utils/feign'
export default {
    data() {
        return {
            currentTab: 'home', // 默认选中首页
            currentCardIndex: 0, // 当前卡片索引
            currentRoom: 'all', // 添加当前房间状态
            userName:'',
            // 添加天气数据对象
            weatherData: {
                temperature: '--',
                weather: '获取中...',
                humidity: '--',
                windpower: '--'
            },
            // 添加地区信息
            locationInfo: {
                adcode: '110000',
                city: '北京市'
            },
            iotData: {
                beep: 0,
                sc: 0,
                temp: 0,
                light: 0,
                humi: 0,
                air: 0,
                sp: 0,
                people: 0,
                led: 0
            },
            deviceList: [],
            isCenterActive: false, // 添加中间按钮状态
            thresholds: {
                temperature: { high: 30, low: 16 },
                humidity: { high: 70, low: 30 },
                light: { high: 800, low: 200 },
                smoke: { warning: 50 },
                peopleTime: 0, // 记录检测到人的时间
                lightOnTime: {} // 记录灯光开启时间
            },
            mqttTimer: null, // 添加MQTT定时器
            categories: [], // 添加分类配置

        }
    },
    computed: {
        // 修改后的设备过滤逻辑
        filteredDevices() {
            if (this.currentRoom === 'all') {
                return this.deviceList;
            }
            return this.deviceList.filter(device =>
                device.room === this.currentRoom
            );
        },
        // 根据天气状况返回对应的样式类名
        getWeatherClass() {
            const weather = this.weatherData.weather;
            if(weather.includes('雨')) {
                return 'weather-rainy';
            } else if(weather.includes('云') || weather.includes('阴') || weather.includes('雾')) {
                return 'weather-cloudy';
            } else {
                return 'weather-sunny';
            }
        }
    },
    onLoad() {
        // 初始化获取分类数据
        // 从后端获取用户名
        this.fetchUserName();
        this.fetchCategories();
        this.fetchDevices();
        const app = getApp();
        // 确保 deviceList 被正确初始化
        if (!app.globalData.deviceList || app.globalData.deviceList.length === 0) {
            app.globalData.deviceList = this.deviceList; // 使用页面的 deviceList

            console.log('初始化全局设备列表:', app.globalData.deviceList);
        }

        // 其他初始化代码保持不变
        uni.setStorageSync('deviceList', JSON.stringify(app.globalData.deviceList));

        // 同时保存一份到 'categoryConfig'，供分类管理页面使用
        const roomGroups = {};
        this.deviceList.forEach(device => {
            const room = device.room || '未分类';
            if (!roomGroups[room]) {
                roomGroups[room] = {
                    name: room,
                    devices: []
                };
            }

            roomGroups[room].devices.push(device);
        });

        const categories = Object.values(roomGroups);
        uni.setStorageSync('categoryConfig', JSON.stringify(categories));

        // 初始获取一次数据
        app.eventBus.on('mqttMessage', (message) => {
            console.log('Received MQTT message:', message);
            this.updateIotData(message);
        });

        // 启动定时器，每10秒获取一次数据
        this.mqttTimer = setInterval(() => {
            // 发送MQTT消息获取数据
            const app = getApp();
            if (app.globalData.mqtt_client) {
                app.globalData.mqtt_client.publish('/k23b3hySH5l/wxdevice/user/get', JSON.stringify({
                    method: "thing.service.property.get",
                    id: Date.now().toString(),
                    params: {},
                    version: "1.0.0"
                }));
            }
        }, 10000); // 10秒间隔

        // 获取位置和天气信息
        this.getLocation();

        // 加载分类配置并立即应用
        const savedConfig = uni.getStorageSync('categoryConfig');
        if (savedConfig) {
            try {
                const categories = JSON.parse(savedConfig);
                this.updateDeviceCategories(categories);
                console.log('已加载并应用分类配置');
            } catch (error) {
                console.error('解析分类配置失败:', error);
            }
        }


    },
    onUnload() {
        const app = getApp();
        app.eventBus.off('mqttMessage');
        // 清除定时器
        if (this.mqttTimer) {
            clearInterval(this.mqttTimer);
            this.mqttTimer = null;
        }
    },
    onShow() {

        // 强制更新视图
        this.$forceUpdate();
        this.fetchDevices();
        this.fetchCategories();
        // 每次显示页面时重新获取用户名
        this.fetchUserName();

        // 刷新设备列表
        const savedDeviceList = uni.getStorageSync('deviceList');
        if (savedDeviceList) {
            try {
                this.deviceList = JSON.parse(savedDeviceList);
            } catch (error) {
                console.error('解析设备列表失败:', error);
            }
        }
    },
    methods: {
        // 获取位置信息
        async getLocation() {
            try {
                // 获取用户IP地址
                const res = await uni.request({
                    url: 'https://restapi.amap.com/v3/ip',
                    data: {
                        key: 'f063532b06bdab254ce0b50ee483a00d',
                        output: 'JSON'
                    }
                });

                if (res.data.status === '1') {
                    console.log('地区信息:', res.data);
                    this.locationInfo = {
                        adcode: res.data.adcode,
                        city: res.data.city
                    };
                    // 获取到位置后再获取天气
                    this.getWeather();
                } else {
                    throw new Error(res.data.info || '获取位置失败');
                }
            } catch(err) {
                console.error('获取位置失败:', err);
                uni.showToast({
                    title: '获取位置失败',
                    icon: 'none'
                });
                // 使用默认位置获取天气
                this.getWeather();
            }
        },
        // 获取天气信息
        async getWeather() {
            try {
                const res = await uni.request({
                    url: 'https://restapi.amap.com/v3/weather/weatherInfo',
                    data: {
                        key: 'c7202db97a4412ff625361294ecc12c8',
                        city: this.locationInfo.adcode,
                        extensions: 'base'
                    }
                });

                if (res.data.status === '1' && res.data.lives && res.data.lives[0]) {
                    const weatherInfo = res.data.lives[0];
                    console.log('天气数据:', weatherInfo);

                    // 更新天气数据
                    this.weatherData = {
                        temperature: weatherInfo.temperature,
                        weather: weatherInfo.weather,
                        humidity: weatherInfo.humidity,
                        windpower: weatherInfo.windpower
                    }
                }
            } catch(err) {
                console.error('获取天气失败:', err);
                uni.showToast({
                    title: '获取天气失败',
                    icon: 'none'
                });
            }
        },
        // 切换标签页
        switchTab(tab) {
            this.currentTab = tab;
            switch(tab) {
                case 'notify':
                    uni.redirectTo({
                        url: '/pages/notify/notify',
                        animationType: 'pop-in',
                        animationDuration: 200
                    });
                    break;
                case 'control':
                    uni.redirectTo({
                        url: '/pages/control/control',
                        animationType: 'pop-in',
                        animationDuration: 200
                    });
                    break;
                case 'setting':
                    uni.redirectTo({
                        url: '/pages/setting/setting',
                        animationType: 'pop-in',
                        animationDuration: 200
                    });
                    break;
            }
        },
        // 获取图标路径
        getTabIcon(tab) {
            const baseUrl = '../../static/';
            return this.currentTab === tab ?
                `${baseUrl}${tab}-active.png` :
                `${baseUrl}${tab}.png`;
        },
        // 处理卡片滑动
        handleSwiperChange(e) {
            this.currentCardIndex = e.detail.current;
        },
        //分类请求
        async fetchCategories() {
            try {
                const res = await uni.request({
                    url: 'http://127.0.0.1:7878/category',
                    method: 'GET'
                });

                console.log('分类数据:', res);

                // uni.request 返回的是 { data, statusCode, header, errMsg }，需要访问 res.data
                const response = res.data; // 确保这里是 res.data，而不是 res[1].data
                console.log('解析后的分类数据:', response);

                if (response.code === 200) {
                    this.categories = response.data; // 确保 response.data 是正确的数据数组
                } else {
                    uni.showToast({
                        title: '获取分类失败: ' + response.msg,
                        icon: 'none'
                    });
                }
            } catch (error) {
                console.error('获取分类失败:', error);
                uni.showToast({
                    title: '网络错误，请检查连接',
                    icon: 'none'
                });
            }
        },
        // 获取设备列表
        async fetchDevices() {
            try {
                const response = await deviceApi.getDeviceList()
                console.log('设备接口返回:', response) // 添加日志

                // UniApp 的 uni.request 返回结构略有不同
                if (response.statusCode === 200 && response.data.code === 200) {
                    this.deviceList = response.data.data.map(device => ({
                        ...device,
                        data: {
                            temperature: '--',
                            humidity: '--',
                            value: '--'
                        },
                        hasSwitch: device.type === '灯光' || device.type === '蜂鸣器'
                    }))
                } else {
                    uni.showToast({
                        title: '获取设备失败',
                        icon: 'none'
                    })
                }
            } catch (error) {
                console.error('获取设备失败:', error)
                uni.showToast({
                    title: '网络错误，请检查连接',
                    icon: 'none'
                })
            }
        },

        // 切换房间
        switchRoom(id) {
            this.currentRoom = id === 'all' ? 'all' : `room-${id}`;
        },
        // 处理中间按钮点击
        handleCenterClick() {
            this.isCenterActive = !this.isCenterActive;
            // 添加页面跳转
            uni.redirectTo({
                url: '/pages/deepseek/deepseek',
                animationType: 'pop-in',
                animationDuration: 200
            });
        },
        // 更新IoT数据
        // 修改updateIotData方法，确保正确映射设备类型和数据
        updateIotData(message) {
            try {
                console.log('Processing message:', message);
                const data = JSON.parse(message);
                if (data && data.items) {
                    console.log('Parsed data items:', data.items);
                    // 更新 iotData
                    Object.keys(data.items).forEach(key => {
                        this.iotData[key] = data.items[key].value;
                        console.log(`Updated ${key}:`, this.iotData[key]);
                    });

                    // 更新设备列表数据
                    this.deviceList.forEach(device => {
                        console.log('正在更新设备:', device.type, device);

                        // 根据设备类型映射到相应的IoT数据
                        switch(device.type) {
                            case 'tempHumidity':
                                device.data = {
                                    ...device.data,
                                    temperature: this.iotData.temp ? `${this.iotData.temp}` : '--',
                                    humidity: this.iotData.humi ? `${this.iotData.humi}` : '--',
                                    value: `${this.iotData.temp || '--'}°C/${this.iotData.humi || '--'}%`
                                };
                                break;
                            case '灯光':
                                device.data = {
                                    ...device.data,
                                    value: this.iotData.LED ? '开启' : '关闭'
                                };
                                break;
                            case '空气质量':
                                device.data = {
                                    ...device.data,
                                    value: this.iotData.air ? `${this.iotData.air} mg/m³` : '--'
                                };
                                break;
                            case '烟雾浓度':
                                // 注意这里使用sp而非sc
                                device.data = {
                                    ...device.data,
                                    value: this.iotData.sp ? `${this.iotData.sp} mg/m³` : '--'
                                };
                                break;
                            case '光照强度':
                                // 注意这里使用sc而非light
                                device.data = {
                                    ...device.data,
                                    value: this.iotData.sc ? `${this.iotData.sc} lux` : '--'
                                };
                                break;
                            case '人体检测':
                                device.data = {
                                    ...device.data,
                                    value: this.iotData.people ? '有人' : '无人'
                                };
                                break;
                            case '蜂鸣器':
                                device.data = {
                                    ...device.data,
                                    value: this.iotData.beep ? '开启' : '关闭'
                                };
                                break;
                        }
                        console.log(`设备 ${device.type} 更新后:`, device.data);
                    });

                    // 强制更新视图
                    this.$forceUpdate();
                }
            } catch (error) {
                console.error('解析IoT数据失败:', error);
                console.error('Failed message:', message);
            }
        },
        // 更新设备分类
        updateDeviceCategories(categories) {
            if (categories && categories.length > 0) {
                // 遍历每个设备并更新其房间分类
                categories.forEach(category => {
                    category.devices.forEach(device => {
                        // 在设备列表中查找对应设备
                        const targetDevice = this.deviceList.find(d => d.type === device.type);
                        if (targetDevice) {
                            targetDevice.room = category.name;
                            console.log(`设备 ${targetDevice.type} 更新到房间 ${category.name}`);
                        }
                    });
                });

                // 强制更新视图
                this.$forceUpdate();

                // 保存更新后的设备列表
                const app = getApp();
                app.globalData.deviceList = [...this.deviceList];

                // 保存到本地存储，确保重新打开时保持更新
                uni.setStorageSync('deviceList', JSON.stringify(this.deviceList));
            }
        },
        generateNotification(type, message, icon = '⚠️') {
            const notification = {
                icon: icon,
                title: type,
                desc: message,
                time: new Date().toLocaleTimeString(),
                offset: 0,
                read: false
            };

            // 获取全局通知数组
            let notifications = uni.getStorageSync('notifications') || [];
            notifications.unshift(notification);
            // 最多保存20条通知
            if (notifications.length > 20) {
                notifications.pop();
            }
            uni.setStorageSync('notifications', notifications);
        },
        handleCardClick(cardInfo, event) {
            if (cardInfo.type === '电量使用') {
                uni.navigateTo({
                    url: '/pages/power/power'
                });
            } else {
                // 针对其他设备，跳转到设备详情页
                uni.navigateTo({
                    url: `/pages/deviceDetail/deviceDetail?type=${cardInfo.type}`
                });
            }
        },
        // 从后端获取用户名
        fetchUserName() {
            uni.request({
                url: 'http://127.0.0.1:7878/user',
                method: 'GET',
                success: (res) => {
                    if (res.data.code === 200 && res.data.data) {
                        this.userName = res.data.data.name;
                    } else {
                        console.error('获取用户名失败:', res.data.msg);
                    }
                },
                fail: (err) => {
                    console.error('获取用户名请求失败:', err);
                    uni.showToast({
                        title: '获取用户信息失败',
                        icon: 'none'
                    });
                }
            });
        }
    }
}